// package value 提供统一的多类型值访问与转换能力
//
// 核心目标：简化任意类型值到目标类型的转换过程，屏蔽原始类型差异，通过标准化接口提供一致的访问方式。
//
// 主要组件：
//   - Value 接口：定义了一套完整的类型转换方法，涵盖基础类型（int/string等）、切片类型（[]int/[]string等）、
//     复合类型（map/slice）及通用扫描（Scan）能力，支持直接获取目标类型值或注入到指定指针。
//   - NewValue 函数：创建Value接口实例的构造函数，可包装任意原始值（支持nil）。
//   - value 结构体：Value接口的默认实现，内部通过依赖rconv包完成具体类型转换，复用成熟的转换逻辑。
//
// 核心特性：
//  1. 类型无关访问：无论原始值是基础类型（int/string等）、指针、切片还是复杂结构体，均能通过统一方法（如Int()/String()）获取目标类型。
//  2. 丰富转换支持：覆盖基础类型、对应切片类型、time.Duration、[]interface{}、map[string]interface{}等，满足多场景需求。
//  3. 通用扫描能力：通过Scan方法将值注入任意类型指针（包括自定义结构体），基础类型直接赋值，复杂类型通过JSON序列化实现转换。
//  4. 低耦合设计：具体转换逻辑依赖rconv包，本包专注于接口封装，保证转换规则一致性的同时降低维护成本。
//
// 典型场景：
//   - 配置解析：从配置文件（如JSON/YAML）读取的动态值，需转换为不同类型使用。
//   - 数据绑定：网络请求参数、数据库查询结果等动态数据，需转换为业务层所需类型。
//   - 动态值处理：在不确定输入值类型的场景下（如脚本引擎、动态表单），简化类型转换逻辑。
//
// 使用方式：
//  1. 通过NewValue包装原始值，得到Value接口实例。
//  2. 调用接口方法直接获取目标类型（如v.Int()、v.Strings()）。
//  3. 对复杂类型，使用Scan方法注入到目标指针（如结构体变量）。
package value

import (
	"gameServer/encoding/json"
	"gameServer/utils/rconv"
	"time"
)

// Value 接口：定义统一的多类型值访问契约
// 设计意图：为任意类型的值提供标准化的类型转换入口，无需关注原始类型，直接获取目标类型数据
// 核心能力：覆盖基础类型、切片类型、复合类型（map/slice）的转换，以及通用扫描和原始值访问
type Value interface {
	// 基础类型获取方法：返回对应基础类型的值
	Int() int
	Int8() int8
	Int16() int16
	Int32() int32
	Int64() int64
	Uint() uint
	Uint8() uint8
	Uint16() uint16
	Uint32() uint32
	Uint64() uint64
	Float32() float32
	Float64() float64
	Bool() bool
	String() string
	Duration() time.Duration

	// 切片类型获取方法：返回对应类型的切片
	Ints() []int
	Int8s() []int8
	Int16s() []int16
	Int32s() []int32
	Int64s() []int64
	Uints() []uint
	Uint8s() []uint8
	Uint16s() []uint16
	Uint32s() []uint32
	Uint64s() []uint64
	Float32s() []float32
	Float64s() []float64
	Bools() []bool
	Strings() []string
	Bytes() []byte
	Durations() []time.Duration

	// 复合类型获取方法
	Slice() []interface{}        // 转换为[]interface{}类型切片
	Map() map[string]interface{} // 转换为map[string]interface{}类型映射

	// 通用扫描：将值写入目标指针（支持基础类型和复杂类型）
	Scan(pointer interface{}) error
	// 原始值访问：返回内部存储的原始值
	Value() interface{}
}

// value 结构体：Value接口的具体实现
// 内部存储原始值v，所有类型转换均依赖rconv包的转换函数，实现接口定义的各类方法
type value struct {
	v interface{} // 存储原始值，支持任意类型
}

// NewValue 创建Value接口实例
// 功能：提供便捷的实例化方式，支持无参（默认存储nil）和单参数（存储输入值）
// 参数：v - 可选参数，若传入多个参数仅保留第一个；无参则存储nil
// 返回值：Value接口实例，包装了输入的原始值
func NewValue(v ...interface{}) Value {
	if len(v) == 0 {
		return &value{v: nil} // 无参时，内部存储nil
	}
	return &value{v: v[0]} // 有参时，存储第一个参数作为原始值
}

// 基础类型转换方法：均通过调用rconv包对应函数实现，复用rconv的类型转换逻辑
// 注：以下方法逻辑一致（仅目标类型不同），统一说明：
// 调用rconv.XXX(v.Value())，将内部原始值转换为目标类型并返回

func (v *value) Int() int {
	return rconv.Int(v.Value())
}

func (v *value) Int8() int8 {
	return rconv.Int8(v.Value())
}

func (v *value) Int16() int16 {
	return rconv.Int16(v.Value())
}

func (v *value) Int32() int32 {
	return rconv.Int32(v.Value())
}

func (v *value) Int64() int64 {
	return rconv.Int64(v.Value())
}

func (v *value) Uint() uint {
	return rconv.Uint(v.Value())
}

func (v *value) Uint8() uint8 {
	return rconv.Uint8(v.Value())
}

func (v *value) Uint16() uint16 {
	return rconv.Uint16(v.Value())
}

func (v *value) Uint32() uint32 {
	return rconv.Uint32(v.Value())
}

func (v *value) Uint64() uint64 {
	return rconv.Uint64(v.Value())
}

func (v *value) Float32() float32 {
	return rconv.Float32(v.Value())
}

func (v *value) Float64() float64 {
	return rconv.Float64(v.Value())
}

func (v *value) Bool() bool {
	return rconv.Bool(v.Value())
}

func (v *value) String() string {
	return rconv.String(v.Value())
}

func (v *value) Duration() time.Duration {
	return rconv.Duration(v.Value())
}

// 切片类型转换方法：均通过调用rconv包对应切片转换函数实现，复用rconv的切片转换逻辑
// 注：以下方法逻辑一致（仅目标切片类型不同），统一说明：
// 调用rconv.XXXs(v.Value())，将内部原始值转换为目标类型切片并返回

func (v *value) Ints() []int {
	return rconv.Ints(v.Value())
}

func (v *value) Int8s() []int8 {
	return rconv.Int8s(v.Value())
}

func (v *value) Int16s() []int16 {
	return rconv.Int16s(v.Value())
}

func (v *value) Int32s() []int32 {
	return rconv.Int32s(v.Value())
}

func (v *value) Int64s() []int64 {
	return rconv.Int64s(v.Value())
}

func (v *value) Uints() []uint {
	return rconv.Uints(v.Value())
}

func (v *value) Uint8s() []uint8 {
	return rconv.Uint8s(v.Value())
}

func (v *value) Uint16s() []uint16 {
	return rconv.Uint16s(v.Value())
}

func (v *value) Uint32s() []uint32 {
	return rconv.Uint32s(v.Value())
}

func (v *value) Uint64s() []uint64 {
	return rconv.Uint64s(v.Value())
}

func (v *value) Float32s() []float32 {
	return rconv.Float32s(v.Value())
}

func (v *value) Float64s() []float64 {
	return rconv.Float64s(v.Value())
}

func (v *value) Bools() []bool {
	return rconv.Bools(v.Value())
}

func (v *value) Strings() []string {
	return rconv.Strings(v.Value())
}

func (v *value) Bytes() []byte {
	return rconv.Bytes(v.Value())
}

func (v *value) Durations() []time.Duration {
	return rconv.Durations(v.Value())
}

// Slice 将原始值转换为[]interface{}类型切片
// 实现逻辑：调用rconv.Interfaces转换原始值，复用rconv的切片转接口切片能力
func (v *value) Slice() []interface{} {
	return rconv.Interfaces(v.Value())
}

// Map 将原始值转换为map[string]interface{}类型映射
// 实现逻辑：通过Scan方法将值扫描到空map指针，转换失败返回nil
func (v *value) Map() map[string]interface{} {
	m := make(map[string]interface{})
	// 调用Scan尝试将原始值写入map指针，失败则返回nil
	if err := v.Scan(&m); err != nil {
		return nil
	}
	return m
}

// Scan 核心功能：将内部原始值写入目标指针（支持基础类型和复杂类型）
// 设计意图：提供通用的"值注入"能力，无需关心原始类型，直接填充目标变量，内容存储在结构体中，通过类型判断进行存储
// 实现逻辑：
//  1. 基础类型指针：直接调用对应转换方法赋值（高效无额外开销）
//  2. 复杂类型（如结构体、自定义类型）：通过JSON序列化+反序列化实现通用转换
func (v *value) Scan(pointer interface{}) error {
	// 处理基础类型指针：直接赋值
	switch p := pointer.(type) {
	case *int:
		*p = v.Int()
	case *int8:
		*p = v.Int8()
	case *int16:
		*p = v.Int16()
	case *int32:
		*p = v.Int32()
	case *int64:
		*p = v.Int64()
	case *uint:
		*p = v.Uint()
	case *uint8:
		*p = v.Uint8()
	case *uint16:
		*p = v.Uint16()
	case *uint32:
		*p = v.Uint32()
	case *uint64:
		*p = v.Uint64()
	case *float32:
		*p = v.Float32()
	case *float64:
		*p = v.Float64()
	case *bool:
		*p = v.Bool()
	case *string:
		*p = v.String()
	case *time.Duration:
		*p = v.Duration()
	// 处理复杂类型：通过JSON序列化+反序列化实现转换
	default:
		switch val := v.Value().(type) {
		// 原始值为字符串或字节切片：直接作为JSON源反序列化
		case string, *string:
			return json.Unmarshal(v.Bytes(), pointer)
		case []byte, *[]byte:
			return json.Unmarshal(v.Bytes(), pointer)
		// 其他类型：先序列化为JSON字节，再反序列化到目标指针
		default:
			b, err := json.Marshal(val)
			if err != nil {
				return err // 序列化失败（如循环引用），返回错误
			}
			return json.Unmarshal(b, pointer)
		}
	}
	// 基础类型赋值成功，返回nil
	return nil
}

// Value 返回内部存储的原始值
// 作用：提供原始值访问入口，方便在需要原始类型时直接使用（如特殊转换逻辑）
func (v *value) Value() interface{} {
	return v.v
}
